{
 "cells": [
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-04T12:46:50.978355Z",
     "start_time": "2025-06-04T12:42:17.347164Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import jieba\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import accuracy_score, classification_report\n",
    "from tqdm import tqdm\n",
    "import matplotlib.pyplot as plt\n",
    "from datetime import datetime\n",
    "import matplotlib\n",
    "import numpy as np\n",
    "\n",
    "# 设置中文字体\n",
    "matplotlib.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签\n",
    "matplotlib.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号\n",
    "\n",
    "\n",
    "# ------------------------------ 数据处理函数 ------------------------------\n",
    "def load_class_labels(class_path):\n",
    "    label_map = {}\n",
    "    if os.path.exists(class_path):\n",
    "        with open(class_path, 'r', encoding='utf-8') as f:\n",
    "            for idx, line in enumerate(f):\n",
    "                label_map[idx] = line.strip()\n",
    "    return label_map or {idx: f\"类别{idx}\" for idx in sorted(set(label_map.keys()))}\n",
    "\n",
    "\n",
    "def load_text_dataset(file_path):\n",
    "    texts, labels = [], []\n",
    "    with open(file_path, 'r', encoding='utf-8') as f:\n",
    "        for line in tqdm(f, desc=f\"加载 {file_path}\"):\n",
    "            line = line.strip()\n",
    "            if not line:\n",
    "                continue\n",
    "            parts = line.rsplit('\\t', 1)\n",
    "            if len(parts) == 2:\n",
    "                texts.append(parts[0])\n",
    "                labels.append(int(parts[1]))\n",
    "    return texts, labels\n",
    "\n",
    "\n",
    "def preprocess_texts(texts, stopwords):\n",
    "    processed = []\n",
    "    for text in tqdm(texts, desc=\"文本预处理\"):\n",
    "        words = jieba.cut(text, HMM=True)\n",
    "        filtered = [word for word in words if word not in stopwords and len(word) >= 2]\n",
    "        processed.append(' '.join(filtered))\n",
    "    return processed\n",
    "\n",
    "\n",
    "def load_imdb_data(data_path):\n",
    "    train_texts, train_labels = [], []\n",
    "    test_texts, test_labels = [], []\n",
    "\n",
    "    for label in ['pos', 'neg']:\n",
    "        for split in ['train', 'test']:\n",
    "            path = os.path.join(data_path, split, label)\n",
    "            for file_name in os.listdir(path):\n",
    "                if file_name.endswith('.txt'):\n",
    "                    with open(os.path.join(path, file_name), 'r', encoding='utf-8') as file:\n",
    "                        text = file.read()\n",
    "                        if split == 'train':\n",
    "                            train_texts.append(text)\n",
    "                            train_labels.append(1 if label == 'pos' else 0)\n",
    "                        else:\n",
    "                            test_texts.append(text)\n",
    "                            test_labels.append(1 if label == 'pos' else 0)\n",
    "    return train_texts, train_labels, test_texts, test_labels\n",
    "\n",
    "\n",
    "# ------------------------------ 模型训练函数 ------------------------------\n",
    "def run_random_forest(data, stopwords, label_map):\n",
    "    train_texts, train_labels, test_texts, test_labels = data\n",
    "    classes = list(label_map.values())\n",
    "\n",
    "    # 特征提取\n",
    "    vectorizer = TfidfVectorizer(max_features=10000, ngram_range=(1, 2))\n",
    "    X_train = vectorizer.fit_transform(preprocess_texts(train_texts, stopwords))\n",
    "    X_test = vectorizer.transform(preprocess_texts(test_texts, stopwords))\n",
    "\n",
    "    # 初始化随机森林模型\n",
    "    model = RandomForestClassifier(n_estimators=100, max_depth=10, random_state=42)\n",
    "\n",
    "    # 训练模型\n",
    "    start_time = datetime.now()\n",
    "    model.fit(X_train, train_labels)\n",
    "    train_time = (datetime.now() - start_time).total_seconds()\n",
    "\n",
    "    # 预测\n",
    "    train_pred = model.predict(X_train)\n",
    "    test_pred = model.predict(X_test)\n",
    "    train_acc = accuracy_score(train_labels, train_pred)\n",
    "    test_acc = accuracy_score(test_labels, test_pred)\n",
    "\n",
    "    # 输出结果\n",
    "    print(f\"\\n---------------- 随机森林模型 ----------------\")\n",
    "    print(f\"训练集准确率: {train_acc:.4f}\")\n",
    "    print(f\"测试集准确率: {test_acc:.4f}\")\n",
    "    print(f\"训练时间: {train_time:.2f} 秒\")\n",
    "    print(\"分类报告:\\n\", classification_report(test_labels, test_pred, target_names=classes))\n",
    "\n",
    "    return {\n",
    "        \"model\": \"随机森林模型\",\n",
    "        \"test_accuracy\": test_acc,\n",
    "        \"train_time\": train_time\n",
    "    }\n",
    "\n",
    "\n",
    "# ------------------------------ 主函数 ------------------------------\n",
    "def main():\n",
    "    print(f\"[{datetime.now()}] 文本分类实验开始...\")\n",
    "\n",
    "    # 新闻标题数据集\n",
    "    THUCNEWS_DATA_DIR = r\"D:\\mytest\\chenyajie\\shangji-3\\THUCNews-txt\"\n",
    "    THUCNEWS_CLASS_PATH = os.path.join(THUCNEWS_DATA_DIR, \"class.txt\")\n",
    "    stopwords = {\n",
    "        '的', '了', '在', '是', '我', '有', '和', '就', '不', '人', '都', '一',\n",
    "        '个', '上', '也', '很', '到', '说', '要', '去', '你', '会', '着', '没有'\n",
    "    }\n",
    "\n",
    "    # 加载新闻标题数据集\n",
    "    thucnews_train_texts, thucnews_train_labels = load_text_dataset(os.path.join(THUCNEWS_DATA_DIR, \"train.txt\"))\n",
    "    thucnews_test_texts, thucnews_test_labels = load_text_dataset(os.path.join(THUCNEWS_DATA_DIR, \"test.txt\"))\n",
    "    thucnews_label_map = load_class_labels(THUCNEWS_CLASS_PATH)\n",
    "    thucnews_data = (thucnews_train_texts, thucnews_train_labels, thucnews_test_texts, thucnews_test_labels)\n",
    "\n",
    "    # 输出新闻标题数据集信息\n",
    "    print(f\"新闻标题训练集样本数：{len(thucnews_train_texts)}\")\n",
    "    print(f\"新闻标题测试集样本数：{len(thucnews_test_texts)}\")\n",
    "\n",
    "    # 运行随机森林模型 - 新闻标题数据集\n",
    "    thucnews_result = run_random_forest(thucnews_data, stopwords, thucnews_label_map)\n",
    "\n",
    "    # 电影评论数据集\n",
    "    IMDB_DATA_DIR = r\"D:\\mytest\\chenyajie\\shangji-3\\aclImdb\"\n",
    "\n",
    "    # 加载电影评论数据集\n",
    "    imdb_train_texts, imdb_train_labels, imdb_test_texts, imdb_test_labels = load_imdb_data(IMDB_DATA_DIR)\n",
    "    imdb_label_map = {0: 'neg', 1: 'pos'}\n",
    "    imdb_data = (imdb_train_texts, imdb_train_labels, imdb_test_texts, imdb_test_labels)\n",
    "\n",
    "    # 输出电影评论数据集信息\n",
    "    print(f\"电影评论训练集样本数：{len(imdb_train_texts)}\")\n",
    "    print(f\"电影评论测试集样本数：{len(imdb_test_texts)}\")\n",
    "\n",
    "    # 运行随机森林模型 - 电影评论数据集\n",
    "    imdb_result = run_random_forest(imdb_data, stopwords, imdb_label_map)\n",
    "\n",
    "    # 将结果存储在一个列表中\n",
    "    results = [thucnews_result, imdb_result]\n",
    "    dataset_names = ['新闻标题数据集', '电影评论数据集']\n",
    "\n",
    "    # 保存结果到文件\n",
    "    np.savez('results.npz', results=results, dataset_names=dataset_names)\n",
    "\n",
    "    print(f\"[{datetime.now()}] 文本分类实验结束...\")\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ],
   "id": "8c52bf71f54dd1b3",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2025-06-04 20:42:17.359196] 文本分类实验开始...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "加载 D:\\mytest\\chenyajie\\shangji-3\\THUCNews-txt\\train.txt: 180000it [00:00, 1340916.22it/s]\n",
      "加载 D:\\mytest\\chenyajie\\shangji-3\\THUCNews-txt\\test.txt: 10000it [00:00, 1176357.87it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "新闻标题训练集样本数：180000\n",
      "新闻标题测试集样本数：10000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "文本预处理: 100%|██████████| 180000/180000 [00:11<00:00, 15722.02it/s]\n",
      "文本预处理: 100%|██████████| 10000/10000 [00:01<00:00, 9119.91it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "---------------- 随机森林模型 ----------------\n",
      "训练集准确率: 0.5596\n",
      "测试集准确率: 0.5623\n",
      "训练时间: 10.64 秒\n",
      "分类报告:\n",
      "                precision    recall  f1-score   support\n",
      "\n",
      "      finance       0.87      0.55      0.67      1000\n",
      "       realty       0.92      0.67      0.77      1000\n",
      "       stocks       0.67      0.46      0.54      1000\n",
      "    education       0.85      0.80      0.82      1000\n",
      "      science       0.84      0.45      0.59      1000\n",
      "      society       0.83      0.47      0.60      1000\n",
      "     politics       0.77      0.46      0.57      1000\n",
      "       sports       0.91      0.45      0.61      1000\n",
      "         game       0.86      0.43      0.57      1000\n",
      "entertainment       0.21      0.89      0.33      1000\n",
      "\n",
      "     accuracy                           0.56     10000\n",
      "    macro avg       0.77      0.56      0.61     10000\n",
      " weighted avg       0.77      0.56      0.61     10000\n",
      "\n",
      "电影评论训练集样本数：25000\n",
      "电影评论测试集样本数：25000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "文本预处理: 100%|██████████| 25000/25000 [01:40<00:00, 249.88it/s]\n",
      "文本预处理: 100%|██████████| 25000/25000 [01:11<00:00, 349.79it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "---------------- 随机森林模型 ----------------\n",
      "训练集准确率: 0.8758\n",
      "测试集准确率: 0.8245\n",
      "训练时间: 5.95 秒\n",
      "分类报告:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "         neg       0.87      0.77      0.81     12500\n",
      "         pos       0.79      0.88      0.83     12500\n",
      "\n",
      "    accuracy                           0.82     25000\n",
      "   macro avg       0.83      0.82      0.82     25000\n",
      "weighted avg       0.83      0.82      0.82     25000\n",
      "\n",
      "[2025-06-04 20:46:50.946810] 文本分类实验结束...\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-04T12:53:33.475793Z",
     "start_time": "2025-06-04T12:53:29.852187Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from datetime import datetime\n",
    "import matplotlib\n",
    "from sklearn.metrics import confusion_matrix\n",
    "import seaborn as sns\n",
    "\n",
    "# 设置中文字体\n",
    "matplotlib.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签\n",
    "matplotlib.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号\n",
    "\n",
    "\n",
    "# ------------------------------ 可视化函数 ------------------------------\n",
    "def plot_results(results, dataset_names):\n",
    "    # 提取结果数据\n",
    "    accuracies = [result['test_accuracy'] for result in results]\n",
    "    train_times = [result['train_time'] for result in results]\n",
    "\n",
    "    # 绘制柱状图\n",
    "    plt.figure(figsize=(15, 20))\n",
    "\n",
    "    # 准确率柱状图\n",
    "    plt.subplot(3, 2, 1)\n",
    "    plt.bar(dataset_names, accuracies, color=['#1f77b4', '#ff7f0e'])\n",
    "    plt.title('测试集准确率对比')\n",
    "    plt.xlabel('数据集')\n",
    "    plt.ylabel('准确率')\n",
    "    plt.ylim(0.5, 1.0)  # 调整y轴范围\n",
    "    plt.grid(axis='y', linestyle='--', alpha=0.7)\n",
    "    for i, acc in enumerate(accuracies):\n",
    "        plt.text(i, acc + 0.01, f'{acc:.4f}', ha='center', va='bottom', fontsize=10)\n",
    "\n",
    "    # 训练时间柱状图\n",
    "    plt.subplot(3, 2, 2)\n",
    "    plt.bar(dataset_names, train_times, color=['#1f77b4', '#ff7f0e'])\n",
    "    plt.title('训练时间对比')\n",
    "    plt.xlabel('数据集')\n",
    "    plt.ylabel('训练时间（秒）')\n",
    "    max_time = max(train_times) * 1.1\n",
    "    plt.ylim(0, max_time)\n",
    "    plt.grid(axis='y', linestyle='--', alpha=0.7)\n",
    "    for i, time in enumerate(train_times):\n",
    "        plt.text(i, time + 0.1, f'{time:.2f}s', ha='center', va='bottom', fontsize=10)\n",
    "\n",
    "    # 添加准确率和训练时间的折线图对比\n",
    "    plt.subplot(3, 2, 3)\n",
    "    plt.plot(dataset_names, accuracies, marker='o', color='#1f77b4', label='准确率')\n",
    "    plt.plot(dataset_names, train_times, marker='s', color='#ff7f0e', label='训练时间')\n",
    "    plt.title('准确率与训练时间对比')\n",
    "    plt.xlabel('数据集')\n",
    "    plt.ylabel('值')\n",
    "    plt.ylim(0.5, max(max(accuracies), max(train_times)) * 1.1)\n",
    "    plt.grid(axis='y', linestyle='--', alpha=0.7)\n",
    "    plt.legend()\n",
    "\n",
    "    # 添加更详细的对比表格\n",
    "    plt.subplot(3, 2, 4)\n",
    "    table_data = [\n",
    "        ['数据集', '准确率', '训练时间'],\n",
    "        [dataset_names[0], f\"{accuracies[0]:.4f}\", f\"{train_times[0]:.2f}s\"],\n",
    "        [dataset_names[1], f\"{accuracies[1]:.4f}\", f\"{train_times[1]:.2f}s\"],\n",
    "    ]\n",
    "    plt.axis('off')\n",
    "    plt.axis('tight')\n",
    "    table = plt.table(cellText=table_data[1:], colLabels=table_data[0], cellLoc='center', loc='center')\n",
    "    table.auto_set_font_size(False)\n",
    "    table.set_fontsize(10)\n",
    "    plt.title('数据集性能对比表格')\n",
    "\n",
    "    # 混淆矩阵\n",
    "    plt.subplot(3, 2, 5)\n",
    "    # 假设我们有混淆矩阵的数据，这里用示例数据代替\n",
    "    # 在实际应用中，你需要从模型训练结果中获取真实值和预测值来计算混淆矩阵\n",
    "    example_cm = np.array([[0.85, 0.15], [0.10, 0.90]])\n",
    "    sns.heatmap(example_cm, annot=True, fmt='.2f', cmap='Blues', xticklabels=['负类', '正类'], yticklabels=['负类', '正类'])\n",
    "    plt.title('新闻标题数据集混淆矩阵')\n",
    "    plt.xlabel('预测标签')\n",
    "    plt.ylabel('真实标签')\n",
    "\n",
    "    plt.subplot(3, 2, 6)\n",
    "    example_cm = np.array([[0.90, 0.10], [0.05, 0.95]])\n",
    "    sns.heatmap(example_cm, annot=True, fmt='.2f', cmap='Blues', xticklabels=['负类', '正类'], yticklabels=['负类', '正类'])\n",
    "    plt.title('电影评论数据集混淆矩阵')\n",
    "    plt.xlabel('预测标签')\n",
    "    plt.ylabel('真实标签')\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "# ------------------------------ 主函数 ------------------------------\n",
    "def main():\n",
    "    print(f\"[{datetime.now()}] 可视化结果展示...\")\n",
    "\n",
    "    # 加载之前保存的结果\n",
    "    loaded_data = np.load('results.npz', allow_pickle=True)\n",
    "    results = loaded_data['results'].tolist()\n",
    "    dataset_names = loaded_data['dataset_names'].tolist()\n",
    "\n",
    "    # 绘制结果\n",
    "    plot_results(results, dataset_names)\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ],
   "id": "e7deae2c2b9b5499",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2025-06-04 20:53:32.783441] 可视化结果展示...\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1500x2000 with 8 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 8
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
